System and Apparatus for Providing Network Security

ABSTRACT

A rule engine receives data flows. The data flows are between a network and an application. The rule engine determines data flow information and in dependence on the information performs an action with respect to said flow. A controller provides control information to the rule engine to define one or more actions. The communications between said rule engine and said controller are secure.

CROSS-REFERENCE TO OTHER APPLICATIONS

This application is a continuation of U.S. patent application Ser. No.14/660,812, filed 17 Mar. 2015, entitled SYSTEM AND APPARATUS FORPROVIDING NETWORK SECURITY (Attorney Docket No. LVL5 2041-1). Thisapplication is incorporated herein by reference.

BACKGROUND OF THE INVENTION

Some embodiments of the invention relate to a system and apparatus forproviding security within a network environment.

SUMMARY

In some embodiments, there is provided a system comprising: a ruleengine configured to receive data flows, said data flows being between anetwork and an application, said rule engine being provided between saidnetwork and said application, said rule engine being configured todetermine data flow information and in dependence on said information toperform an action with respect to said flow; and a controller, saidcontroller configured to provide control information to said rule engineto define one or more actions, wherein communications between said ruleengine and said controller are secure.

The controller may be configured to receive information from said ruleengine about said data flows.

The rule engine may have a first data store configured to store at leastone first key.

The controller may have a second data store configured to store at leastone second key.

At least one of said first and second data stores may comprise a onetime programmable memory.

At least one of said first and second data stores may comprise ahardware security module.

At least one of said first and second keys may be stored in said datastore at manufacture.

At least one of said rules engine and said controller may be configuredto receive a message from a trusted authority and to verify said messageusing a respective key of said at least one first key and said at leastone second key.

The message received by the controller may comprise a public keyassociated with said at least one first key of the rules engine and themessage received by the rule engine may comprise at least one public keyassociated with the at least one second key of the controller.

One of said rules engine and said controller may be configured to send amessage to the other of said rules engine and said controller, saidmessage encrypted by a public key and signed with a private key of saidone of said rules engine and said controller, said message comprising afurther key to use for said secure communications between the rulesengine and the controller.

The rule engine may be provided in a first trusted domain and saidcontroller may be provided in a second trusted domain, different to thefirst domain

The controller may be provided in a trusted virtual machine.

The rules engine may be provided in a network interface device.

The rules engine may be provided in a hypervisor.

A plurality of rules engines may be provided.

The data flow information may comprise header information.

The controller may be configured to provide a look up function for atleast one data flow for said rules engine.

The controller may be configured to provide a look up function if saiddata flow information associated with a respective dataflow is notpresent in said rules engine.

The rules engine may be is configured to perform a look up operation independence on said data flow information, said look operation providingone or more of state associated with the data flow, at least one rule,delivery information and a count.

The rules engine may comprise an execution block configured to performsaid at least one action defined by said rule and update information ina data store of said rules engine.

The rules engine may be provided in hardware, in software or in hardwareand software.

The controller may be provided in hardware, in software or in hardwareand software.

According to an embodiment, there is provided an apparatus comprising: arule engine configured to receive data flows, said data flows beingbetween a network and an application, said rule engine being providedbetween said network and said application, said rule engine beingconfigured to determine data flow information and in dependence on saidinformation to perform an action with respect to said flow, said ruleengine configured to receive control information from a controllerdefining one or more of said actions, wherein communications betweensaid rule engine and said controller are secure.

According to an embodiment, there is provided an apparatus comprising: acontroller, said controller configured to provide control information toa rule engine to define one or more actions, the rule engine configuredreceive data flows between a network and an application and to performan action with respect to said flow, wherein communications between saidrule engine and said controller are secure.

According to an embodiment, there is provided an apparatus comprising: arule engine configured to receive data flows, said data flows beingbetween a network and an application, said rule engine being providedbetween said network and said application, said rule engine beingconfigured to determine data flow information and in dependence on saidinformation to perform an action with respect to said flow, said ruleengine configured to receive control information from a controllerdefining one or more of said actions, wherein communications betweensaid rule engine and said controller are secure.

According to an embodiment, there is provided a computer programproduct, the computer program product being embodied on a non-transientcomputer-readable medium and configured so as when executed on aprocessor to provide a rule engine which: receives data flows, said dataflows being between a network and an application; determines data flowinformation and in dependence on said information to perform an actionwith respect to said flow; and receives control information from acontroller defining one or more of said actions, wherein communicationsbetween said rule engine and said controller are secure.

According to an embodiment, there is provided a computer programproduct, the computer program product being embodied on a non-transientcomputer-readable medium and configured so as when executed on aprocessor to provide a controller which: provides control information toa rule engine to define one or more actions, the rule engine configuredreceive data flows between a network and an application and to performan action with respect to said flow, wherein communications between saidrule engine and said controller are secure.

BRIEF DESCRIPTION OF DRAWINGS

Some embodiments will now be described by way of example only withreference to the accompanying Figures in which:

FIG. 1 shows a schematic overview of a network architecture in whichsome embodiments may be provided;

FIG. 2 shows a first example of an architecture with a distributedserver edge network security product;

FIG. 3 shows a second example of an architecture with a distributedserver edge network security product;

FIG. 4 shows a third example of an architecture with a distributedserver edge network security product;

FIG. 5 shows a fourth example of an architecture with a distributedserver edge network security product;

FIG. 6 shows a functional view of a rules engine and a controller;

FIG. 7 shows an overview of a system in which embodiments may beprovided; and

FIG. 8 shows a tool which can be used to manage security policy in someembodiments.

DETAILED DESCRIPTION OF EMBODIMENTS

The following description is presented to enable any person skilled inthe art to make and use the invention, and is provided in the context ofa particular application. Various modifications to the disclosedembodiments will be readily apparent to those skilled in the art.

The general principles defined herein may be applied to otherembodiments and applications without departing from the spirit and scopeof the present invention. Thus, the present invention is not intended tobe limited to the embodiments shown, but is to be accorded the widestscope consistent with the principles and features disclosed herein.

Some embodiments may provide a distributed server edge network securityproduct.

Corporate data centers may need to be protected, for example from anumber of attacks and breaches which at present may exploiting internalcommunications and which may not be caught by traditional firewall andintrusion detection techniques. For example employees may access andexport data from within an organization either maliciously orinadvertently, subverting existing security provisions. Breachedequipment which having been compromised may then be used to stagefurther penetration within an organization

Another form of attack is where a network is used to bombard serverswith attack patterns or traffic designed to degrade performance. This issometimes referred to as distributed denial of service. (DDoS)

Some companies allow the bringing in of people's own devices. This mayincrease exposure of the internal network to potential attacks.Increasingly such devices are communicating using encrypted protocolssuch as SSL (secure sockets layer) which unless decrypted by a firewalldevice represent a further potential breach of security.

All of the above are further exacerbated by the increase of data-centereast-west traffic and leaf-spine network architectures. East-westtraffic is the traffic that goes between servers in a given data centeror the like. The leaf-spine architecture is also known as a distributedcore. This architecture has spine switches and leaf switches. The spinecomprises high-throughput layer 3 switches. The leaf switches are theaccess layer and provide network connection points for servers. Eachleaf switch will generally connects to every spine switch.

The growing desire to use cloud-like provisioning and deployment ofsoftware-defined networks makes the situation more complex since thephysical locality of services becomes lost. Enumerating L4 (IP-flow)like rules for a complex enterprise network can be a daunting task andmanaging the resulting huge rule sets may be difficult. Further, manyservices themselves depend on edge devices possessing sensitivecryptographic key information which key information should be protected.

Generally, the further away a policy is defined from a destination hostthe more permissive it usually is due to the complexity of systems,networks, and services that exists below the implementation point.

In some embodiments server/service specific policy may be applied at thedistributed edge. This may provide for enhanced service delivery and/ora more resilient infrastructure when under attack.

There are a number of ways by which a network interface function mayimprove these security issues in some embodiments.

Reference is made to FIG. 1 which schematically shows an arrangementwhere a data processor 2 such as a server is configured to communicatewith a network 6 via a network interface device 4, sometimes referred toa NIC. A network interface device could be provided in any suitableform, including as a peripheral device or integrated with the hardwareof a host data processing device. A data processor could be any kind ofcomputer system, including a server, personal computer, or a bespokeprocessing unit. A network interface device as described herein providesan interface to a network for use by its host data processing device. Inthis document, reference is made to a security providing NIC. It shouldbe appreciated that this security providing NIC may be any suitablenetwork interfacing device.

The security providing NIC while logically a component of a server maycan be considered to be a physically separate and distinct piece ofhardware and logically distinct network entity.

In some embodiments, the NIC may be implemented by a hardware device. Inother embodiments, the NIC may be implemented by a hardware device alongwith software in an operating system for example.

The NIC in some embodiments, does not execute application code. The NICmay only be accessed through highly crypto-secure interfaces. The NICmay be constructed to be tamper resistant. The NIC may be regarded assecure gatekeeper between the server and the network, protecting boththe network from malicious or faulty servers and the server from thenetwork. The network may be an untrusted and/or compromised network. Theserver may be an untrusted and/or compromised server.

The NIC may be a party to every network flow through the server. The NICis able to monitor which application is communicating and to where. TheNIC may be able to prevent flows being established between unauthorizednetworks and/or domains. By monitoring the actual flows which arehappening in real time each NIC can report and so collaboratively maygenerate an entire connectivity graph for a data center for analysis.

The NIC may be able to detect many of the common attacks based onprotocol within frame headers or the traffic's temporal behavior. Forexample, a very small TCP window size or a very high connection rate maybe indicative of anomalous behavior. For such packets, the NIC canenforce by immediately dropping or querying another entity, or monitorby reporting and generating alerts.

The NIC may provide a control point. In some embodiments, byestablishing an overlay network which enables distributed control of theNIC functions, a layer of network management can be provided which maybe cryptographically secure and/or where control can be restricted to asmall set of authorized operators.

This layer may act which can be used to protect against bad-actoremployees who may otherwise have administrative access to servers andswitches. In some embodiments, this layer may be retro-fitted to acompany's or the like internal network.

In some embodiments, the NIC may provide one or more of the following:

-   -   monitoring and/or securing of every network packet;    -   provide a protected and/or tamper resistant execution domain;    -   isolate and/or identify compromised servers;    -   protect servers and/or data from network attack; and    -   protect organizations from malicious operators.

Some embodiments may provide a distributed server edge network securityproduct which provide the secure NIC function which may be implementedusing hardware and/or software components and which is securely managedover the data center or network.

Logically the secure NIC or security system comprises a rule engine anda controller. It is possible that the two are physically co-located forexample both on a host or both on a physical NIC. If they are separatedthen communication between the rule engine and the controller may takeplace via a channel which is cryptographically or otherwise secure. Forexample the rule engine may be on the physical NIC and the controllermay be implemented on a server. Various different embodiments will nowbe described.

In some embodiments, the rule engine may be provided in one trusteddomain and the controller may be provided in a different trusted domain.The communication between the rule engine and controller is secure,using for example encryption.

Reference is made to FIG. 2 which shows a first architecture havingdistributed server edge network security. The arrangement of FIG. 2 hasfilter engine software with a controller 16 and a rules engine 14. Acontrol plane 15 is provided there between. The filter engine softwaremay be provided by a server and may be provided in the operating systemand/or user space. The controller 16 and rules engine 14 may provide adistributed server edge network security.

In the arrangement shown in FIG. 2, an application 8 is provided. Theapplication 8 may be provided by a server and is typically provided inthe user space. The filter engine 10 is implemented in software andprovides the controller 16 and the rules engine 14. The NIC 12 has NICrelated hardware components 44.

The communication between the NIC hardware and the application 8 may becontrolled and/or monitored by a rules engine 14. The function providedby the rules engine 14 is controlled by a controller 16. The controlplane 15 provided between the controller 16 and the rules engine 14allows the controller to provide control information to the rules engineand/or for the rules engine to provide information to the controller. Aspart of the filter engine, a management component 18 may be provided.This may comprise one or more connector functions 22, 24, 26 which maymanage the NIC. A function may provide a standalone managementapplication (for example with GUI (graphical user interface and/or a CLI(command line interface) for a virtual appliance). Alternatively oradditionally the function may interface directly with IT orchestrationsystems such as Puppet, third party threat information sources such asthe Norse Dark List, and/or as an object exposed through CIM (commoninformation module).

Communication between the management component 18 of the filter engineand a corresponding management function 20 is provided via a network 6.The functions may be provided on different servers of an internalnetwork. The corresponding management function may provide a respectiveclient 28 or 30 for a function provided by the management component 18.For example if the management component 18 comprises a Puppet connector,the respective management function comprises a Puppet client. If a CIMprovider 24 is provided in the management component, a respective CIMclient is provided in the corresponding management function. It shouldbe appreciated that in some embodiments, not all of the functionsprovided in the management component 18 will have a correspondingfunction in the corresponding management function 20.

The rules engine may record all flow associated to and/or from theapplication. The rules engine may report to the controller via thecontrol plane. The rules engine may have one or more rules which have anenforcement function. Some examples of the rules and the interactionwith the controller will be described in more detail later.

The securing of the control plane may be achieved in any suitablemanner. For example the securing of the network could be achieved forexample by using strong hash authenticated messages over a network. Someexamples of the securing of the control plane will be described later.

Reference is made to FIG. 3 which shows a second architecture having adistributed server edge network security. Those parts which generallycorrespond to those in FIG. 2 have the same reference. In FIG. 3, thecontroller 16 and management component 18 are instantiated within astand-alone appliance 48. This is referred to a policy server in thisdocument. This may be a first trusted domain.

The rules engine 14 is implemented by the hardware 44 within thephysical NIC and may be separated from the appliance by a network. TheNIC may be a second trusted domain. The control plane traffic may becarried over the same network as the traffic to which the NIC isapplying rules, or via an alternative network or network partition. Theapplication 8 may be provided by a server 46, different to the sever 48providing the controller.

The rule engine and controller both may be constructed so as to betamper resistant. When the rule engine is implemented on a physical NIC,the physical design should resist probe and glitch attacks. Any keystored in non-volatile memory 45 of the NIC may be inaccessible, forexample through the use of on-die one time programmable memory ornonvolatile micro fuses. Protocols used to establish a secure channelshould be resistant to man in the middle and other attacks where thephysical interface could be entirely replaced. When implemented insoftware the controller should execute in a trusted execution domain,for example a virtual appliance running within an operating systemconfigured with high security.

While the source code of the controller may be restricted, it should notbe the case that any knowledge of this code would assist an attack. Insome embodiments, the only interfaces supported by the controller arethe secure channels to the rule engines and a hardened API (applicationprogramming interface). This API may be designed to minimize the attacksurface of the controller and may protect the integrity of thecontroller against malicious clients. This API provides an interface tothe management component in some embodiments.

The API may use one or more of the following techniques:

-   -   strongly typing of parameters including storage requirements;    -   separated address spaces with parameter copy and verification;    -   digitally signed and authenticated API invocations (using        physical authentication tokens); and    -   minimization of entry points and their semantics.

Reference is made to FIG. 4 which shows a third architecture having adistributed server edge network security. Those parts which generallycorrespond to those in FIG. 2 or 3 have the same reference. A server 2provides the application 8 which is protected by the filter engine 10.The filter engine 10 has the controller 16 and the management component.The filter engine may be provided in the operating system and/or userspace. The controller at least is in a trusted domain.

The rules engine 14 may be provided in the operating system 14 alongwith a driver 42 for the NIC. The controller may thus be integrated withsoftware which is used to manage the secure NIC. This may be any one ormore of the functions of the management component.

Reference is made to FIG. 5 which shows another architecture having adistributed server edge network security. Those parts which generallycorrespond to those in FIG. 2, 3 or 4 have the same reference. As withthe arrangement of the FIG. 3, the filter engine 18 and controller 16are provided by, for example a policy server 48.

The policy server 58 may be provided in a trusted VM (virtual machine)controlling both hardware and software rules engines. A VM 50 is anuntrusted VM and may support an application (not shown). In thisembodiment, the secure appliance or policy server 58 is implemented as avirtual machine. In some embodiments, the secure appliance may berunning on the same physical server as the guests which are beingprotected. The filter engine and controller are thus running in atrusted VM in some embodiments.

The untrusted VM is protected by the software and hardware rule engines.

In some embodiments, such as shown in FIG. 5, the distributed serveredge network security may have a plurality of rules engines 14 a and 14b which are implemented in hardware and software. The rules engines maybe used in combination for example to partition the checking. This mayrequire the flows to be balanced across two or more rules engines.Alternatively or additionally, the rules engines may be used to layeradditional features or properties. For example a software rules enginemay have access to large amounts of memory and so can scale to largenumbers of rules whereas a rules engine on a NIC may be moreconstrained.

In the example of FIG. 5, a rules engine 14 a and driver 42 is inprovided in a Hypervisor or host and a rules engine 14 b is provided inthe NIC 44.

This architecture can used for any suitable hypervisor/container basedenvironments.

In some embodiments, the degree of trust for all entities needs to beunderstood/determined and communicated. Generally it is desirable thatany higher order controller or management software should be aware ofthe level of trust and be able to cope with an environment potentiallycomprising compromised elements, for example rules engines which areconsidered to be bad actors.

In some embodiments, driver filter insertion requests are proxied over aControl Plane to an authoritative trusted daemon.

The operation of the rules engine and controller and the logicalseparation of functions are illustrated in FIG. 6.

The rules engine 14 may be required to process network frames athigh-speed. A parser 100 is configured to parse and classify a receiveframe. The parser may parse through network headers for example any oneor more of Layer 2, 3 and 4 headers and application headers such ashttp. A given classification triggers a number of lookup operations by alook up function 102. The lookup operations may be expressed through aprogrammable micro-engine 112. These operations may comprise one or moreof perfect matching or longest prefix matching of headers through toregular expression matching over the entire frame and, inlinedecryption. The capabilities of the rule engine may effect the amount ofstate available for lookup.

For some embodiments, where there is insufficient storage availablelocally at the rules engine (for example an ASIC implementation), thelook up function should treat the local state as a cache and request afill, or authoritative answer from the controller. During the time takento respond to such a request, the NIC may be required to drop packets orbackpressure the network.

The lookup operation to data store 112 will typically return some stateassociated with the identified network flow 116, an action or rule 118,delivery information 120 and a counter 122. One example action would beto monitor, where it is only required for the rule engine to incrementthe counter for this particular network flow. Other actions may be adrop action for black-listing operation or an allow action forwhite-listing. The rule engine may be required to replicate frames foraudit purposes, or modify frames so as to enable a timestamp to beinserted, or rate-limit flows. These actions are by way of example andany other suitable actions may alternatively or additionally beperformed. A plurality of actions may be performed for a given workflow.

The execution block 104 of the rule engine performs the required actionand the write-back block 106 returns required changes to the firewallstate 126 in the data store. Thus in some embodiments, state informationassociated with the data flows is stored. This may comprise incrementingthe flow counter or inserting a new flow if the rules engine has beenconfigured to self-learn rather than to be populated with rules providedby the controller. Some rule engines may provide a combination orself-learning and use rules provided by the controller.

The rules engine has control plane function 110 which is configured toencrypt messages sent to the controller via the control plane anddecrypt messages received from the controller via the control plane.This is discussed in more detail later.

The state may contain delivery information, for example to allowparticular flows to be directed to different receive interfaces.

The rules engine may periodically provide its state relating to the dataflows to its controller and/or the controller may request state from therules engine. This provided by the reporting function 108 of the rulesengine. This in turn allows reports to be provided by the reportingfunction 108′ of the controller, for example, the network-flows whichare actually established over a given time period can be usefulinformation. Where the rules engine is required to provide a loggingaction, such events can be delivered through the reporting mechanism.

The rule engine may provide one or more of the following functions:

Parse all incoming and outgoing frames, for example through L4;

Match all frames according to the filter types using the NIC residentlookup table and a number of operational modes;

Match frames according to a user specified bitmask and frame offsetrelative to a set of classified header boundaries;

If no match is made, a monitor mode may insert a matching filter andinitial count into the filter table. The frame may be deliveredaccording to a default delivery configuration;

If no match is made, a blacklist mode may deliver the frame according tothe default delivery configuration;

If no match is made, a whitelist mode may drop the frame and generate analert;

If no match is made, a proxy mode may query an associated controllerelement for an action and process the frame as though this informationwere matched in the NIC resident lookup table-in this mode during thequery the data flow can be blocked or dropped;

If a match is found, the lookup table may present an action (rule),delivery information and a counter. The rule engine may do one or moreof deliver, drop, replicate, and rate-limit and insert a timestampto/into the frame according to the action and delivery information. Therule engine may update the lookup table according to the action,delivery information and counter.

If filter table is full when inserting a new flow, the rules engine mayage out old flows based on LRU (least recently used) or some otherappropriate heuristic This may involve the old flow state includingstatistics being sent to the controller which could later refresh if theflow becomes active again;

Generate logging and alerts;

Maintain counters for statistics on actions;

Periodically and/or in response to queries from the controller, therules engine may send one or more of the contents of the filter table,logging and alerts to the controller; and

The rules engine may receive the filter table and configurationinformation from the controller and may not require any support fromsoftware or drivers running on a local server.

The rules engine may be implemented in FPGA, by an ASIC or any othersuitable entity.

A hardened API 143, such as described earlier, is provided between thefilter engine and the controller. The controller has a look up functionfor cache misses or for an authoritative response. The look up may be toa data store 112′. The data store 112′ may replicate the information inthe rules engine, for an network flow 116′, for example an action (rule)118′, delivery information 120′ and a count 122′ as well as firewallstate 112′.

The controller is able to provide an authoritative response if the rulesengine is not. In that scenario, the rules engines acts as a cache.

The controller has function 140 for configuring policy and rules.

The controller has control plane function 110′ which is configured toencrypt messages sent to the rules engine via the control plane anddecrypt messages received from the rules engine via the control plane.This is discussed in more detail later.

The controller may as schematically shown communicate with a pluralityof rules engines 14. The rules engine (or each or the rules engines)will have a secure control plane with the controller.

In some embodiments, there may be a plurality of controllers. This maybe to deal with failure of a controller and/or for effective managementof a network. Secure communication such as between the rules engines andthe controller may be provided between the controllers.

In some embodiments, each rule engine will use a different key tocommunicate with the same controller. In some embodiments, a controllermay communicate with different controllers using different keys. Thecontrollers may communicate to share state so that failover is possiblefrom one controller to another.

The controller may be implemented in a secure manner with a runtimewhich is resistance to attack.

The controller may execute in a hardened (relatively secure) OSenvironment.

The controller may control a large number of rules engine instances. Byway of example only, some controllers may control the order of a 1000rules engines.

In the event of a problem, the controller may be able to failover toanother controller and to restart. In some embodiments, the plurality ofcontrollers may not maintain state consistency across the controller.

The controller may have an API to receive configuration information andrules from management connectors or local administration. This may befrom the connection management function.

The controller may log and store API operations for audit purposes. Forexample time, date, and identity may be stored. Identity may be a useridentity, a flow identity and/or a functional block or entity identity.

The controller may receive or enforce API operations which are digitallysigned or otherwise authenticated. The controller may therefore be setup with authentication credentials of for example the managementconnection function or administrative function.

The controller may be arranged to disseminate configuration informationand rules to the rules engines.

The controller may be arranged to periodically query the rules enginesfor state updates.

The controller may be arranged to monitor and report the health andactivity state of all rules engines including logging and alerts.

The controller may be arranged to respond to requests for authoritativerule lookups from rules engines.

The controller may be arranged to receive events, logging, statisticsand flow table information from the rules engines and report thisinformation over the API to management connection function.

In some embodiments, the controller may in addition to implementing asecure NIC functionality implement remote management operations over aset of NICs. The set may comprise a plurality of NICs.

In some embodiments, the controller may allow persistent NICconfiguration settings to be set and reported. In some embodiments, thecontroller may allow NIC partitioning configuration to be set andreported.

In some embodiments, the controller may allow QoS (quality of service)configuration to be set and reported.

The controller may support the gathering and remote monitoring of NICoperational statistics.

The control plane between the controller and the rule engine isencrypted using encryption keys. Any suitable mechanism for thedistribution of keys may be used. In some embodiments, it may bepossible to configure one or more or all NICs in a deployment to becontrolled only by their controller instances.

For example serial numbers for NICs are harvested and a file producedwhich is used to lookup the appropriate keys for the controller and NICinstances. Some embodiments may use asymmetric (or public-key) basedexchanges in order to establish these communication channels of thecontrol plane.

In order to avoid, for example, an attack where bad public keys arereported to controllers, the authority determines public keys from aknown list indexed on serial numbers. The distributed lists arethemselves digitally signed by the authority which could be any suitableentity. The NICs and the controllers are programmed securely with thekey required to verify this digital signature.

In some embodiments, the rules engine may be programmed at manufactureor at a trusted customer location to securely store cryptographic keyinformation. In some embodiments, at least some of the storedcryptographic key information may be unique to the particular rulesengine.

A hardware based rules engine may be designed to not release thisinformation nor to allow it to be subsequently modified. A softwarebased rules engine may use a HSM (Hardware Security Module) at thecontroller to store these keys in a secure manner.

In some embodiments, the NIC may be used as a secure place to store thekeys and effectively act as an HSM. The NIC may store the keys for therules engine (regardless of whether or not the rules engine is on theNIC) and/or for the controller.

In some embodiments, sensitive material may be stored in the ASIC forthe benefit of applications. For example to allow server data to bestored only in an encrypted format and used decrypted by the NIC. Thismay provide an integration of HSM and NIC functionality.

Each controller may be programmed at manufacture or at a trustedlocation to securely store cryptographic key information. At least someof the stored information may be unique to the particular Controller.Integrity of the controller may require the use of a HSM to store thesekeys in a secure manner.

The rules engines and controllers may both receive messages from anauthority and verify their authenticity using some or all of the storedcryptographic key information. The authority could be any suitabletrusted authority. Messages from the authority are signed/verified usingHMAC (hash based message authentication code). Thus in some embodiments,there is a trusted authority which may for example generate HMAC signedmessages.

Sets of rules engines and their controllers may be identified before orafter customer deployment and bound to one another. This may via aprocess to physically identify the sets of communicating entities.

In some embodiments, the serial numbers of a set of NICs can beharvested in situ or through customer support databases. The controllersmay be assumed to operate within a trusted environment and areidentifiable. The rules engines may be assumed to be tamper resistantbut operating in a hostile environment. This hostile environment mayinclude manipulation of harvested serial numbers, the insertion ofmalicious rules engines which attempt to subvert controllers, and theinsertion of malicious controllers which attempt to subvert rulesengines.

Once bound, each controller and rules engine pair know each other'spublic key and their own private key and can therefore communicate viastandard asymmetric cryptography (e.g. RSA-2048) a new random shared keyand establish a unique encrypted revocable communication channel(control plane). Communication over the control plane may use AES-256(advanced encryption standard) or the like symmetric cypher. It may bethat a given controller will need to use a set of cyphers to match thatsupported by the rules engine.

Alternatively, once bound, each controller-rules engine pair maycommunicate a shared key to establish a unique authenticated revocablecommunication channel using HMAC authentication.

The controller may periodically re-establish the control plane withsubsequent communication taking place using a new shared key This maytake place relatively frequently in some embodiments.

The binding process may be repeated to enable the sets of controllersand rules engines to be changed. This is to enable deployment changesand/or revocation of controllers and rules engines.

The control plane messages may be carried using a network protocolappropriate for the hardware on which the Rules Engine is implemented.For example the protocol may be UDP—user datagram protocol.

The control plane may employ heartbeats, retransmission and congestionavoidance mechanisms

The following describes a public key infrastructure to implement controlplane establishment. However, it should be appreciated that any othermethod may be used to provide a secure control plane for communicationsbetween the controller and respective rules engine.

A unique public/private key pair may be one time generated atmanufacture or at a trusted location and stored within the rules enginein a tamper resistant manner.

The public key for each rules engine instance is stored in a trustedrepository. The keys may be for use with the RSA-2048 algorithm or thelike. The repository may be indexed by device serial numbers (which canbe harvested from deployed devices).

In some embodiments, the rules engine is not required to release anykey. The repository may not be required to store the rules engineprivate keys.

The private key should be stored securely as each rules engine (NIC)allows. This may be by means of nonvolatile memory in the rule engine.

A unique public/private key pair may be one time generated atmanufacture or at a trusted location and stored within the Controller ina tamper resistant manner. The public key for each controller may bestored in a trusted repository (which may be the same or different tothat used by the rules engines). The keys may be used with the RSA-2048algorithm or the like.

The controller private key may be kept securely and may nevertransmitted outside of the controller. Preferably the controllercontains a HSM.

The repository is not required to store the Controller private keys butmay do so in some embodiments.

The repository is designed to prevent the insertion or tampering withthe public keys to reduce the likely hood of man in the middle attack.The keys themselves are not secret, they are public. However isdesirable to avoid a man in the middle attack where a malicious publickey is injected into the repository.

Each Controller may receive the public keys of the rules engines towhich it is bound from the trusted repository. Each rules engine mayreceive the public keys of the one or more controllers to which it isbound from the trusted repository

Each rules engine may receive a message from the controller andencrypted by the rule engine's public key and (signed with) thecontroller's private key. The message will contain a symmetricencryption/decryption key to use for subsequent secure communicationbetween the rules engine and the controller.

This message could be broadcast, for example over a Layer 2 network.Alternatively, the controller may have received the IP address of eachrules engine when it got the public keys. The rules engine authenticatesthe message (using the known controller public key) and decrypts usingits own private key. The rules engine and Controller will use theresulting encryption key for subsequent communication.

Thus in some embodiments, a secure key exchange between the controllerand the rules engine may be provided and a binding between the pair maybe established. The above steps can be repeated to change thepublic/private keys according to policy. For example policy could allowreprogramming of the keys where the update messages are signed by anauthority, to allow devices to generate new keys (reporting only thepublic key), or to enforce one time only programming of keys intodevices (requiring a device to be recycled if a key is revoked).

In some embodiments, a controller will be able to control more than onerules engines. The rules engines maybe optimized for differentfunctions.

In some embodiments, apparatus may be provided which has rules engineand a NIC function. The apparatus may comprise at least one processorand at least one memory. The rules engine may be part of the NICfunction or separate. The keys may be stored in the NIC. The apparatusmay be a network adaptor.

In other embodiments, the rules engine may be provided by a firewall.

In other embodiments, the rules engine may be provided by a switch.

In other embodiments, the rules engine may be provided in a hypervisor.

The controller may be provided by software running on the server. Theserver will comprise at least one processor and at least one memory

The controller may be provided in a trusted domain.

A computer program may be stored in at least one memory and when run ona processor may be configured to provide the rules engine.

A computer program may be stored in at least one memory and when run ona processor may be configured to provide the controller.

In some embodiments, the data flows passing through the rules engine maybe encrypted for example SSL. The rules engine may perform protocol (forexample TCP-transmission control protocol) reassembly and decrypt theflows before applying rules. The rules here could be regular expressionsover any of the data payload, and could result in all or some of thedecrypted payload being reported over the control plane. Optionally therules engine may re-encrypt the data before passing to the host so thatthe operation is entirely transparent (a man-in the middle SSL bridge).

This may for example be applied in a rules engine provided in a NIC.

These reports which are generated by every controller can be combined inorder to form a connectivity graph for all the servers in thedata-center. This provides information on which applications andservices are communicating, not just which servers are communicating.The information can be used to validate or prune a pre-existing accesscontrol rule set or generate a rule set. This feature may be used forsecuring large flat networks.

Reference is made to FIGS. 7 and 8. FIG. 8 schematically shows a toolwhich can be used to manage security policy based on service levelinformation and monitored flows. The tool is schematically shown as awork flow. FIG. 7 shows the system architecture with which the tool canbe used.

In a first step S1 of the work flow, policy and server information maybe imported from a plurality of data sources. The data sources may be inthe same organization and/or different organizations. The data sourcemay provide information collected by a controller from one or more rulesengines and/or firewall information. In FIG. 7, these data sources arereferences 102, 104 and 106. For example, each data source may be from adifferent business unit. Each of these data sources may administer andinput its own configuration for deployment. However the policymanagement function 116 will be able to provide and enforce overridingpolicies or rules.

In the second step S2 of the workflow, the imported policy and serverinformation is integrated to generate a global connectivity map and arules database. This may be represented by the policy managementfunction 116 of the function 114.

In the third step S3 of the workflow, a ruleset is generated for eachendpoint. The endpoints are represented schematically by 108, 110 and112. Each of these endpoints may each have one or more rules engines.

In the fourth step S4, the rule sets are distributed to the endpoints.This may be using management tools.

In the fifth step S5, at the endpoints, there may be compiling of theendpoint's ruleset in accordance with the filtering technology used atthat endpoint.

In the sixth step S6, the endpoints will enforce the rules, monitorflows and learn traffic profiles. This is done by the rules engines asdiscussed previously.

The policy function 116 may define services, which may be complex, theroles of infrastructure and their access to services. For example, itcan be defined which entities are able to communicate with which otherentity. An entity may be a server, a domain, part of a server, part of adomain, user device or any other suitable entity.

In embodiments, the rules engines will parse the data flows in thenetwork and accordingly, information (reports) to the network can beused to provide a connectivity graph showing specific flows. In someembodiments, the data provided can be used to create a higher levelconnectivity graph showing which application is connected to which otherapplication. These higher level graphs can be used to detect unusualnetwork patterns, possible resulting from malicious activity and/or canbe used to assist in network planning for managing traffic flows.

The applicant hereby discloses in isolation each individual featuredescribed herein and any combination of two or more such features, tothe extent that such features or combinations are capable of beingcarried out based on the present specification as a whole in the lightof the common general knowledge of a person skilled in the art,irrespective of whether such features or combinations of features solveany problems disclosed herein, and without limitation to the scope ofthe claims. The applicant indicates that aspects of the presentinvention may consist of any such individual feature or combination offeatures. In view of the foregoing description it will be evident to aperson skilled in the art that various modifications may be made withinthe scope of the invention.

1. A system comprising: a rule engine configured to receive data flows,said data flows being between a network and an application, said ruleengine being provided between said network and said application, saidrule engine being configured to determine data flow information, and independence on said information, to perform an action with respect tosaid flow, said rule engine being associated with at least one firstkey; and a controller configured to provide control information to saidrule engine to define one or more actions which are to be performed withrespect to said flow, said controller being associated with at least onesecond key, wherein said at least one first key and said at least onesecond key are used to encrypt at least one communications between saidrule engine and said controller resulting in at least one communicationsbetween said rule engine and said controller being secure.
 2. The systemas claimed in claim 1, wherein said controller is configured to receiveinformation from said rule engine about said data flows.
 3. The systemas claimed in claim 1, wherein at least one of said first and seconddata stores comprises a one time programmable memory.
 4. The system asclaimed in claim 1, wherein at least one of said first and second datastores comprises a hardware security module.
 5. The system as claimed inclaim 1, wherein the system comprises: a first data store comprisingsaid at least one first key; and a second data store comprising said atleast one second key, wherein at least one of said first and second keyis stored in at least one of said first and second data store atmanufacture.
 6. The system as claimed in claim 1, wherein at least oneof said rules engine and said controller is configured to receive amessage from a trusted authority and to verify said message using arespective key of said at least one first key and said at least onesecond key.
 7. The system as claimed in claim 6, wherein the messagereceived by the controller comprises a public key associated with saidat least one first key and the message received by the rule enginecomprises at least one public key associated with the at least onesecond key.
 8. The system as claimed in claim 1, wherein one of saidrules engine and said controller is configured to send a message to theother of said rules engine and said controller, said message encryptedby a public key and signed with a private key of said one of said rulesengine and said controller, said message comprising a further key to usefor said secure communications between the rules engine and thecontroller.
 9. The system as claimed in claim 1, wherein said ruleengine is provided in a first trusted domain and said controller isprovided in a second trusted domain, different to the first domain. 10.The system as claimed in claim 1, wherein said controller is provided ina trusted virtual machine.
 11. The system as claimed in claim 1, whereinsaid rules engine is provided in a network interface device.
 12. Thesystem as claimed in claim 1, wherein said rules engine is provided in ahypervisor.
 13. The system as claimed in claim 1, wherein a plurality ofrules engines are provided.
 14. The system as claimed in claim 1,wherein said data flow information comprises header information.
 15. Thesystem as claimed in claim 1, wherein the rules engine comprises anexecution block configured to perform said at least one action definedby a rule and update information in a data store of said rules engine.16. A network interface device comprising: a rule engine configured toreceive data flows, said data flows being between a network and anapplication, said rule engine being provided between said network andsaid application, said rule engine being configured to determine dataflow information and in dependence on said information to perform anaction with respect to said flow, said rule engine configured to receivecontrol information from a controller defining one or more of saidactions which are to be performed with respect to said flow, said ruleengine being associated with at least one first key, wherein said atleast one first key is used to encrypt at least one communicationsbetween said rule engine and said controller resulting in said at leastone communications between said rule engine and said controller beingsecure.
 17. A server apparatus comprising: a controller, said controllerconfigured to provide control information to a rule engine in a networkinterface device to define one or more actions, the rule engineconfigured to receive data flows between a network and an applicationand to perform one or more of said actions with respect to said flow,said controller being associated with at least one second key, whereinsaid at least one second key is used to encrypt at least onecommunications between said rule engine and said controller resulting insaid at least one communications between said rule engine and saidcontroller being secure.
 18. A computer program product, the computerprogram product being embodied on a non-transient computer-readablemedium and configured so as when executed on a processor to provide arule engine which: receives data flows, said data flows being between anetwork and an application; determines data flow information and independence on said information to perform an action with respect to saidflow; receives control information from a controller defining one ormore of said actions to be performed with respect to said flow, saidrule engine being associated with at least one first key, wherein saidat least one first key is used to encrypt at least one communicationsbetween said rule engine and said controller resulting in said at leastone communications between said rule engine and said controller beingsecure.
 19. A computer program product, the computer program productbeing embodied on a non-transient computer-readable medium andconfigured so as when executed on a processor to provide a controllerwhich: provides control information to a rule engine in a networkinterface device to define one or more actions, the rule engineconfigured to receive data flows between a network and an applicationand to perform one or more of said actions with respect to said flow,said controller being associated with at least one second key, whereinsaid at least one second key is used to encrypt at least onecommunications between said rule engine and said controller resulting insaid at least one communications between said rule engine and saidcontroller being secure.
 20. A firewall device comprising: a rule engineconfigured to receive data flows, said data flows being between anetwork and an application, said rule engine being provided between saidnetwork and said application, said rule engine being configured todetermine data flow information and in dependence on said information toperform an action with respect to said flow, said rule engine configuredto receive control information from a controller defining one or more ofsaid actions which are to be performed with respect to said flow, saidrule engine being associated with at least one first key; wherein saidat least one first key is used to encrypt at least one communicationsbetween said rule engine and said controller resulting in said at leastone communications between said rule engine and said controller beingsecure.
 21. A switch comprising: a rule engine configured to receivedata flows, said data flows being between a network and an application,said rule engine being provided between said network and saidapplication, said rule engine being configured to determine data flowinformation and in dependence on said information to perform an actionwith respect to said flow, said rule engine configured to receivecontrol information from a controller defining one or more of saidactions which are to be performed with respect to said flow, said ruleengine being associated with at least one first key, wherein said atleast one first key is used to encrypt at least one communicationsbetween said rule engine and said controller resulting in said at leastone communications between communications between said rule engine andsaid controller being secure.
 22. A data processing device comprising ahypervisor, the hypervisor comprising: a rule engine configured toreceive data flows, said data flows being between a network and anapplication, said rule engine being provided between said network andsaid application, said rule engine being configured to determine dataflow information and in dependence on said information to perform anaction with respect to said flow, said rule engine configured to receivecontrol information from a controller defining one or more of saidactions which are to be performed with respect to said flow, said ruleengine being associated with at least one first key; wherein said atleast one first key is used to encrypt at least one communicationsbetween said rule engine and said controller resulting in said at leastone communications between said rule engine and said controller beingsecure.
 23. A system as claimed in claim 1, wherein said at least onefirst key and said at least one second key comprise a shared key.
 24. Asystem as claimed in claim 1, wherein said at least one first key andsaid at least one second key are different.